﻿/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package javax.servlet.http;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;

import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * 提供一个通过扩展子类创建兼容Web站点的HTTP Servlet的抽象类.
 * <code>HttpServlet</code>子类必须至少重写接口中的一个方法,
 * 通常是以下方法的任意一种:
 *
 * <ul>
 * <li> <code>doGet</code>,如果servlet支持 HTTP GET请求
 * <li> <code>doPost</code>, 适用于HTTP POST请求
 * <li> <code>doPut</code>, 适用于HTTP PUT请求
 * <li> <code>doDelete</code>, 适用于HTTP DELETE请求
 * <li> <code>init</code> 和 <code>destroy</code>,管理servlet生命周期中所占用的资源 
 * <li> <code>getServletInfo</code>, 提供关于其自身信息的那个servlet
 * </ul>
 * 
 * 
 * 通常没有重写<code>service</code>方法的必要. 
 * <code>service</code>是按照每个HTTP请求的类型(
 * 以上列出的<code>do</code><i>XXX</i>方法)
 * 将他们分发给协处理方法(即处理器方法- handler methods)处理标准HTTP请求的.
 *
 * <p>同样,通常<code>doOptions</code> 和
 * <code>doTrace</code>方法也没有重写的必要. 
 *
 * <p>Servlets是典型的运行在多线程服务器上的java程序,因而需要明确的是:
 * servlet在必须处理并发请求的同时应当当心同步访问共享资源.
 * 共享资源包含驻留内存数据,例如类的实例,类的成员变量和扩展类的对象,文件,数据库连接,网络连接...
 * 请查看
 * <a href="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">
 * Java Tutorial on Multithreaded Programming</a>
 *  获取更多关于'怎样在java程序中处理多线程'的信息.
 *
 * @author  Various
 * @version $Version$
 */
public abstract class HttpServlet extends GenericServlet
    implements java.io.Serializable {

    private static final String METHOD_DELETE = "DELETE";
    private static final String METHOD_HEAD = "HEAD";
    private static final String METHOD_GET = "GET";
    private static final String METHOD_OPTIONS = "OPTIONS";
    private static final String METHOD_POST = "POST";
    private static final String METHOD_PUT = "PUT";
    private static final String METHOD_TRACE = "TRACE";

    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
    private static final String HEADER_LASTMOD = "Last-Modified";
    
    private static final String LSTRING_FILE =
        "javax.servlet.http.LocalStrings";
    private static ResourceBundle lStrings =
        ResourceBundle.getBundle(LSTRING_FILE);
   
    
    /**
     *  什么都不做, 因为它是一个抽象类.
     */
    public HttpServlet() { }
    
    /**
     * 由服务器来调用(通过<code>service</code>方法)让servlet来处理 GET 请求.
     *
     * <p>重写此方法可以实现对GET请求的支持,同时也会自动实现对HTTP HEAD请求的支持.
     * 所谓的HEAD请求也就是不向响应流中填充实体内容的HTTP GET请求,
     * 不过以上所述内容仅适用于请求头域部分(fields).
     * 
     * <p>当重写这个方法时, 读取请求数据,
     * 写响应的头部, 获取响应的writer或者output流对象, 最后,写响应的数据.
     * 最好包含 content type 和 encoding. 当使用
     * 一个<code>PrintWriter</code> 对象来返回响应时,
     * 在访问
     * <code>PrintWriter</code> 对象之前设置content type.
     *
     * <p>由于HTTP协议中，头部必须在响应体之前被发出，因此servlet容器必须在响应提交之前写头部.
     *
     * <p>有可能的话，应通过{@link javax.servlet.ServletResponse#setContentLength}方法设置 Content-Length头，
     *以允许servlet容器使用持久化的连接来返回对客户端的响应，这样可以改善性能。如果整个响应匹配请求缓存会自动设置内容长度。
     *
     * <p>当使用HTTP 1.1 chunked 编码（意味着响应有一个编码转换头）时，不用设置Content-Length头。
     *
     * <p>GET方法应当是安全的，也就是对于负责的用户不会有边界效应。比如，大多数的查询没有边界效应。如果客户端请求想要修改保存的数据，请求应该使用其他的HTTP方法。 
     *
     * <p>GET方法应该是等幂的，意味着它可以安全地重复。有时使一个方法安全也就是使它等幂。比如。重复查询既是安全也是等幂的，但是在线购买商品或者修改数据则既不安全也不等幂。 
     *
     * <p>如果该请求格式不正确，doGet返回一个HTTP“Bad Request”信息。
     *
     * @param req   一个包含客户端向servlet发出的请求的 {@link HttpServletRequest} 对象
     *
     * @param resp  一个包含servlet向客户端返回的响应的 {@link HttpServletResponse} 对象
     * 
     * @exception IOException   如果servlet处理GET请求时侦测到输入输出错误时抛出 
     *
     * @exception ServletException  i如果GET请求不能被处理则抛出 
     * 
     * @see javax.servlet.ServletResponse#setContentType
     */
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }


 /**
     * 返回 <code>HttpServletRequest</code>
     * 对象上次修改的时间，记为从GMT1970年1月1日零时以来的毫秒数。
     *如果时间未知，方法返回一个负数（默认的）。
     *
     * <p>应该重写该方法使servlet支持HTTP GET请求，可以迅速确定上次修改时间。 这使浏览器和代理cache工作更有效，减少服务器和网络资源的加载。 
     *
     * @param req   发送给servlet的<code>HttpServletRequest</code> 
     *                  对象
     *
     * @return  一个<code>long</code> 型整数，指定HttpServletRequest对象上次修改的时间， 记为从GMT1970年1月1日零时以来的毫秒数，如果未知返回-1。
     */
    protected long getLastModified(HttpServletRequest req) {
        return -1;
    }


    /**
     * <p>从protected的<code>service</code>方法中接受一个HTTP HEAD 请求
     * 并且处理这个请求.
     *当客户端只希望看到response的headers，例如Content-Type 或者 Content-Length时，发送一个HEAD请求，
     *HTTP HEAD方法统计response输出的字节数来准确地设置 Content-Length头。
     *
     * <p>如果你重新这个方法，你可以避开计算response body，直接设置response头部来改善性能。
     *保证你所写的<code>doHead</code> 方法是安全的、等幂的（也就是说，保证自己不被一个HTTP HEAD请求多次调用。）
     *
     * <p>如果 HTTP HEAD 请求的格式不正确
     * <code>doHead</code> 返回一个 HTTP "Bad Request"
     * 消息.
     *
     * @param req   传入servlet的请求对象
     *
     * @param resp  servlet用来返回headers给客户端的响应对象
     *
     * @exception IOException   如果发生输入输出错误时抛出
     *
     * @exception ServletException  如果HEAD请求不能被处理则抛出
     */
    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        NoBodyResponse response = new NoBodyResponse(resp);

        doGet(req, response);
        response.setContentLength();
    }


    /**
     *由服务器调用 (通过 <code>service</code> 方法)
     * 来允许servlet处理一个POST请求。
     *
     *  HTTP POST方法允许客户端向Web服务器一次发送无限长度的数据，对于提交比如信用卡号码信息是有用的。 
     *
     * <p>当重写该方法时，读取请求数据，写入请求头，获取请求writer或者输出流对象，
     *最后，写响应数据。最好包括内容类型和编码。当使用<code>PrintWriter</code>对象返回响应时，在方法<code>PrintWriter</code>对象之前设置内容类型。 
     *
     * <p>servlet容器必须在提交响应前写入头，因为HTTP中在响应体前必须发送头。 
     *
     * <p>有可能的话，应通过 {@link javax.servlet.ServletResponse#setContentLength}方法设置 Content-Length头，
     *以允许servlet容器使用持久化的连接来返回对客户端的响应，这样可以改善性能。
     *如果整个响应匹配请求缓存会自动设置内容长度。 
     *
     * <p>当使用HTTP 1.1编码（意味着响应有一个编码转换头）时，不用设置Content-Length头。
     *
     * <p>该方法不需要安全和等幂。通过POST的请求操作对于保持账号的用户有副作用，比如更新保存的数据或在线购物。 
     *
     * <p>如果HTTP POST请求格式不正确，<code>doPost</code>返回一个HTTP“Bad Request”信息。
     *
     *
     * @param req   {@link HttpServletRequest}对象，包含客户端向servlet发出的请求 
     *
     * @param resp  {@link HttpServletResponse}对象，包含servlet向客户端返回的响应 
     * 
     * @exception IOException   如果servlet处理POST请求时发生输入输出错误时抛出 
     *
     * @exception ServletException  如果POST请求不能被处理则抛出
     *
     * @see javax.servlet.ServletOutputStream
     * @see javax.servlet.ServletResponse#setContentType
     */
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }


    /**
     * 由服务器<code>service</code>方法调用来允许servlet处理PUT请求。 
     *
     *PUT操作允许客户端向服务器放置文件，类似地通过FTP发送文件。
     *
     * <p>当重写该方法时，保留完整的发送请求的任何内容头（包括 Content-Length、
     *Content-Type、 Content-Transfer-Encoding、Content-Encoding、Content-Base、Content- Language、
     *Content-Location、 Content-MD5和Content-Range）。如果你的方法不能处理内容头，
     *必须发布错误信息（HTTP 501 - Not Implemented）， 丢弃该请求。关于HTTP 1.1得更多详情，
     *参见
     * <a href="http://www.ietf.org/rfc/rfc2616.txt">RFC 2616</a>。
     *
     * <p>该方法不需要安全和等幂。<code>doPut</code>执行的操作对于保持账号的用户有副作用。
     因此使用该方法时，临时保存一份受影响的 URL的拷贝是有用的。
     *
     * <p>如果HTTP PUT请求格式不正确， <code>doPut</code>返回一个HTTP“Bad Request”信息。 
     *
     * @param req    {@link HttpServletRequest}对象，包含客户端向servlet发出的请求 
     *
     * @param resp  {@link HttpServletResponse} 对象，包含servlet向客户端返回的响应 
     *
     * @exception IOException   如果servlet处理PUT请求时发生输入输出错误时抛出 
     *
     * @exception ServletException  如果PUT请求不能被处理则抛出
     */
    protected void doPut(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_put_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }


    /**
     *由服务器<code>service</code>方法调用来允许servlet处理DELETE请求。 
     *
     * DELETE操作允许客户端删除服务器上的文档或Web页面。 
     * 
     * <p>该方法不需要安全或者等幂。通过DELETE的请求操作对于保持账号的用户有副作用。因此使用该方法时，临时保存一份受影响的URL的拷贝是有用的。 
     *
     * <p>如果HTTP DELETE请求格式不正确，<code>doDelete</code>返回一个HTTP“Bad Request”信息。 
     *
     * @param req   {@link HttpServletRequest}对象，包含客户端向servlet发出的请求 
     *
     *
     * @param resp  {@link HttpServletResponse}对象，包含servlet向客户端返回的响应 
     *
     * @exception IOException   如果servlet处理DELETE请求时发生输入输出错误时抛出 
     *
     * @exception ServletException  如果DELETE请求不能被处理则抛出
     */
    protected void doDelete(HttpServletRequest req,
                            HttpServletResponse resp)
        throws ServletException, IOException {

        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_delete_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }
    

    private static Method[] getAllDeclaredMethods(Class c) {

        if (c.equals(javax.servlet.http.HttpServlet.class)) {
            return null;
        }

        Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
        Method[] thisMethods = c.getDeclaredMethods();
        
        if ((parentMethods != null) && (parentMethods.length > 0)) {
            Method[] allMethods =
                new Method[parentMethods.length + thisMethods.length];
            System.arraycopy(parentMethods, 0, allMethods, 0,
                             parentMethods.length);
            System.arraycopy(thisMethods, 0, allMethods, parentMethods.length,
                             thisMethods.length);

            thisMethods = allMethods;
        }

        return thisMethods;
    }


    /**
     *由服务器<code>service</code>方法调用来允许servlet处理OPTIONS请求。
     *
     *  OPTIONS请求确定服务器支持哪一个HTTP方法，返回一个合适的头。例如，如果servlet重写<code>doGet</code>，方法按以下形式返回头： 
     *
     * <p><code>Allow: GET, HEAD, TRACE, OPTIONS</code>
     *
     * <p> 不需要重写该方法除非servlet实现了新的HTTP方法，超出了HTTP 1.1的实现。
     *
     * @param req   {@link HttpServletRequest} 对象，包含客户端向servlet发出的请求 
     *
     * @param resp  {@link HttpServletResponse} 对象，包含servlet向客户端返回的响应 
     *
     * @exception IOException   如果servlet处理OPTIONS请求时发生输入输出错误时抛出 
     *
     * @exception ServletException  如果OPTIONS请求不能被处理则抛出
     */
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        Method[] methods = getAllDeclaredMethods(this.getClass());
        
        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;
        
        for (int i=0; i<methods.length; i++) {
            Method m = methods[i];
            
            if (m.getName().equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            }
            if (m.getName().equals("doPost")) 
                ALLOW_POST = true;
            if (m.getName().equals("doPut"))
                ALLOW_PUT = true;
            if (m.getName().equals("doDelete"))
                ALLOW_DELETE = true;
        }
        
        String allow = null;
        if (ALLOW_GET)
            if (allow==null) allow=METHOD_GET;
        if (ALLOW_HEAD)
            if (allow==null) allow=METHOD_HEAD;
            else allow += ", " + METHOD_HEAD;
        if (ALLOW_POST)
            if (allow==null) allow=METHOD_POST;
            else allow += ", " + METHOD_POST;
        if (ALLOW_PUT)
            if (allow==null) allow=METHOD_PUT;
            else allow += ", " + METHOD_PUT;
        if (ALLOW_DELETE)
            if (allow==null) allow=METHOD_DELETE;
            else allow += ", " + METHOD_DELETE;
        if (ALLOW_TRACE)
            if (allow==null) allow=METHOD_TRACE;
            else allow += ", " + METHOD_TRACE;
        if (ALLOW_OPTIONS)
            if (allow==null) allow=METHOD_OPTIONS;
            else allow += ", " + METHOD_OPTIONS;
        
        resp.setHeader("Allow", allow);
    }
    
    
    /**
     * 由服务器<code>service</code>方法通过调用来允许servlet处理TRACE请求。
     *
     *TRACE返回发送给客户端的TRACE请求头，因此它们可以用来调试。 不需要重写该方法。 
     *
     * @param req    {@link HttpServletRequest}对象，包含客户端向servlet发出的请求 
     *
     * @param resp  {@link HttpServletResponse}对象，包含servlet向客户端返回的响应 
     *
     * @exception IOException   如果servlet处理TRACE请求时发生输入输出错误时抛出 
     *
     * @exception ServletException  如果TRACE请求不能被处理则抛出
     */
    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException
    {
        
        int responseLength;
        
        String CRLF = "\r\n";
        String responseString = "TRACE "+ req.getRequestURI()+
            " " + req.getProtocol();
        
        Enumeration reqHeaderEnum = req.getHeaderNames();
        
        while( reqHeaderEnum.hasMoreElements() ) {
            String headerName = (String)reqHeaderEnum.nextElement();
            responseString += CRLF + headerName + ": " +
                req.getHeader(headerName); 
        }
        
        responseString += CRLF;
        
        responseLength = responseString.length();
        
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(responseString);        
        out.close();
        return;
    }                


    /**
     * 接受来自public <code>service</code>方法的标准HTTP请求,
     * 并按照类中定义的情形将其发送给<code>do</code><i>XXX</i>方法.
     * 此方法是 {@link javax.servlet.Servlet#service}() HTTP版实现的细节.
     * 方法不需要重写.
     * 
     * @param req  由servlet生成的,含有客户端请求的{@link HttpServletRequest}对象
     *
     * @param resp   servlet返回给客户端的,含有响应流的{@link HttpServletResponse}对象                              
     *
     * @exception IOException   如果servlet处理HTTP请求的过程中发生输入/输出错误
     *
     * @exception ServletException  如果HTTP请求无法处理
     * 
     * @see javax.servlet.Servlet#service
     */
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
            
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);        
            
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
            
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);
            
        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
            
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }


    /*
     * Sets the Last-Modified entity header field, if it has not
     * already been set and if the value is meaningful.  Called before
     * doGet, to ensure that headers are set before response data is
     * written.  A subclass might have set this header already, so we
     * check.
     */
    private void maybeSetLastModified(HttpServletResponse resp,
                                      long lastModified) {
        if (resp.containsHeader(HEADER_LASTMOD))
            return;
        if (lastModified >= 0)
            resp.setDateHeader(HEADER_LASTMOD, lastModified);
    }
   
    
    /**
     * 将客户端请求分发给protected <code>service</code> 方法. 此方法不需要重写. 
     * 
     * @param req  由servlet生成的,含有客户端请求的{@link HttpServletRequest}对象
     *
     * @param res   servlet返回给客户端的,含有响应流的{@link HttpServletResponse}对象                              
     *
     * @exception IOException   如果servlet处理HTTP请求的过程中发生输入/输出错误
     *
     * @exception ServletException  如果HTTP请求无法处理
     * 
     * @see javax.servlet.Servlet#service
     */
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;
        
        try {
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException("non-HTTP request or response");
        }
        service(request, response);
    }
}


/*
 * A response wrapper for use in (dumb) "HEAD" support.
 * This just swallows that body, counting the bytes in order to set
 * the content length appropriately.  All other methods delegate to the
 * wrapped HTTP Servlet Response object.
 */
// file private
class NoBodyResponse extends HttpServletResponseWrapper {
    private NoBodyOutputStream                noBody;
    private PrintWriter                        writer;
    private boolean                        didSetContentLength;

    // file private
    NoBodyResponse(HttpServletResponse r) {
        super(r);
        noBody = new NoBodyOutputStream();
    }

    // file private
    void setContentLength() {
        if (!didSetContentLength)
          super.setContentLength(noBody.getContentLength());
    }


    // SERVLET RESPONSE interface methods

    public void setContentLength(int len) {
        super.setContentLength(len);
        didSetContentLength = true;
    }

    public ServletOutputStream getOutputStream() throws IOException {
        return noBody;
    }

    public PrintWriter getWriter() throws UnsupportedEncodingException {

        if (writer == null) {
            OutputStreamWriter w;

            w = new OutputStreamWriter(noBody, getCharacterEncoding());
            writer = new PrintWriter(w);
        }
        return writer;
    }
}


/*
 * Servlet output stream that gobbles up all its data.
 */
 
// file private
class NoBodyOutputStream extends ServletOutputStream {

    private static final String LSTRING_FILE =
        "javax.servlet.http.LocalStrings";
    private static ResourceBundle lStrings =
        ResourceBundle.getBundle(LSTRING_FILE);

    private int                contentLength = 0;

    // file private
    NoBodyOutputStream() {}

    // file private
    int getContentLength() {
        return contentLength;
    }

    public void write(int b) {
        contentLength++;
    }

    public void write(byte buf[], int offset, int len)
        throws IOException
    {
        if (len >= 0) {
            contentLength += len;
        } else {
            // XXX
            // isn't this really an IllegalArgumentException?
            //难道这里真的是一个IllegalArgumentException异常吗?
            String msg = lStrings.getString("err.io.negativelength");
            throw new IOException(msg);
        }
    }
}
